/**
 * @brief 对于通信连接进行整体管理的一个模块
 * @details
 * 1.connection需要实现channel的可读可写错误连接断开任意事件的回调函数,读事件即从TCP缓存区中读取数据,然后放入到in_buffer中,
 * 然后调用消息到来的回调函数,写事件即将数据写入到TCP的发生缓冲区中,错误和连接断开的回调函数则如果接收缓存区中有数据就先调用消息到来
 * 的回调函数,然后再关闭连接,任意事件的回调函数则如果设置了非活跃连接超时销毁,就刷新定时器,然后调用tcpServer设置的任意事件的回调函数
 * 2.connection有由服务器设置的回调函数,分别为连接建立成功,消息到来,连接关闭,任意事件,服务器保存了所有的连接信息的删除回调函数
 * 3.connection还提供了一个update函数,用于协议的切换:重置上下文,回调函数的重新设置
 */
#pragma once

#include <memory>
#include <functional>

#include "buffer.hpp"
#include "socket.hpp"
#include "eventLoop.hpp"
#include "any.hpp"

namespace hdp
{
    class Connection;
    // DISCONNECTED -- 连接关闭状态   CONNECTING -- 连接建立成功
    // CONNECTED -- 连接建立完成,各种设置已完成,可以通信的状态
    // DISCONNECTING -- 待关闭的状态
    typedef enum
    {
        DISCONNECTED,
        CONNECTING,
        CONNECTED,
        DISCONNECTING
    } ConnStatu;

    using PtrConnection = std::shared_ptr<Connection>;
    class Connection : public std::enable_shared_from_this<Connection>
    {
    private:
        uint64_t _conn_id; // 连接的唯一ID
        // uint64_t _timer_id;            // 定时器ID,必须是唯一的,这块为了简化操作使用conn_id作为定时器ID
        int _sockfd;                   // 连接关联的文件描述符
        bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志,默认为false
        EventLoop *_loop;              // 连接所关联的一个EventLoop
        ConnStatu _statu;              // 连接的状态
        Socket _socket;                // 套接字操作管理
        Channel _channel;              // 连接的事件管理
        Buffer _in_buffer;             // 输入缓冲区--存放从socket中读到的数据
        Buffer _out_buffer;            // 输出缓冲区--存放要发送给对端的数据
        Any _context;                  // 请求的接收处理的上下文
        std::string _clientIp;         // 客户的IP

        /*这四个回调函数，是让服务器模块来设置的(其实服务器模块的处理回调也是组件使用者设置的)*/
        /*换句话说，这几个回调都是组件使用者使用的*/
        using ConnectedCallback = std::function<void(const PtrConnection &)>;
        using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
        using ClosedCallback = std::function<void(const PtrConnection &)>;
        using AnyEventCallback = std::function<void(const PtrConnection &)>;
        ConnectedCallback _connected_callback;
        MessageCallback _message_callback;
        ClosedCallback _closed_callback;
        AnyEventCallback _event_callback;
        /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
        /*就应该从管理的地方移除掉自己的信息*/
        ClosedCallback _server_closed_callback;

    private:
        // 五个Channel的事件回调函数
        // 描述符可读事件触发后的回调函数
        void HandleRead()
        {
            // 1.接收socket的数据,放到缓冲区
            char buffer[65536];
            ssize_t ret = _socket.NonBlockRecv(buffer, 65535);
            if (ret < 0)
            {
                // 出错了，不能直接关闭连接
                return ShutDownInLoop();
            }
            else if (ret == 0)
            {
                // 这里等于0表示的是没有读到数据,而并不是连接断开了,连接断开返回的是-1
                return;
            }

            // 将数据放入输入缓冲区
            _in_buffer.WriteAndPush(buffer, ret);

            // 2.调用message_callback进行业务处理
            if (_in_buffer.ReadAbleSize() > 0)
            {
                // shared_from_this从当前对象自身获取自身的shared_ptr管理对象
                // 需要当前类继承enable_shared_from_this<T>
                return _message_callback(shared_from_this(), &_in_buffer);
            }
        }

        // 描述符可写事件触发后的回调函数,将发送缓冲区中的数据进行发送
        void HandleWrite()
        {
            // _out_buffer中保存的数据就是要发送的数据
            ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
            if (ret < 0)
            {
                // 发送错误就该关闭连接了
                if (_in_buffer.ReadAbleSize() > 0)
                {
                    _message_callback(shared_from_this(), &_in_buffer);
                }
                // 这时是实际关闭连接进行释放
                return Release();
            }

            // 将读偏移向后移动
            _out_buffer.MoveReadOffset(ret);

            // 如果当前是连接关闭状态,则有数据,发送完数据释放连接,没有数据则直接释放连接
            if (_out_buffer.ReadAbleSize() == 0)
            {
                // 没有数据发送了,关闭写事件监控
                _channel.DisableWrite();
                if (_statu == DISCONNECTING)
                    return Release();
            }
            return;
        }

        // 描述符挂断事件触发后的回调函数
        void HandleClose()
        {
            // 一旦连接挂断了，套接字就什么都干不了了，因此有数据待处理就处理一下，完毕关闭连接
            if (_in_buffer.ReadAbleSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release();
        }

        // 描述符错误事件触发后的回调函数
        void HandleError()
        {
            return HandleClose();
        }

        // 描述符任意事件触发后的回调函数
        void HandleEvent()
        {
            if (_enable_inactive_release == true)
            {
                _loop->TimerRefresh(_conn_id);
            }
            if (_event_callback)
            {
                _event_callback(shared_from_this());
            }
        }

        // 连接获取之后,所处的状态下要进行的各种设置(给Channel设置事件回调,启动读监控)
        void EstableishdInLoop()
        {
            // 1.修改连接状态 2.启动读事件监控  3.调用回调函数
            // 当前状态必须一定是上层的半连接状态
            assert(_statu == CONNECTING);
            // 当前函数执行完毕则连接进入已完成连接状态
            _statu = CONNECTED;
            // 一旦启动读事件监控就可能会立即触发读事件,如果这时候启动了非活跃连接销毁
            _channel.EnableRead();

            if (_connected_callback)
                _connected_callback(shared_from_this());
        }

        // 这个接口是实际的释放接口
        void ReleaseInLoop()
        {
            // 1.修改连接状态,将其设置为DISCONNECTED
            _statu = DISCONNECTED;
            // 2.移除连接的事件监控
            _channel.Remove();
            // 3.关闭描述符
            _socket.Close();
            // 4.如果当前定时器队列中还有定时销毁任务,则取消任务
            if (_loop->HasTimer(_conn_id))
                CancelInactiveReleaseInLoop();
            // 5.调用关闭回调函数,避免先移除服务器管理的连接信息导致Connection被释放,再去处理会出错，因此先调用用户的回调函数
            if (_closed_callback)
                _closed_callback(shared_from_this());
            // 6.移除服务器内部管理的连接信息
            if (_server_closed_callback)
                _server_closed_callback(shared_from_this());
        }

        // 这个接口不是真正的发送接口,而只是把数据放到了发送缓冲区,启动了可写事件监控
        void SendInLoop(Buffer &buffer)
        {
            if (_statu == DISCONNECTED)
                return;
            _out_buffer.WriteBufferAndPush(buffer);
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }

        // 这个关闭操作并不是实际的连接关闭释放操作,需要判断还有没有数据待处理,待发送
        void ShutDownInLoop()
        {
            // 将连接设置为半连接状态
            _statu == DISCONNECTING;
            if (_in_buffer.ReadAbleSize() > 0)
            {
                if (_message_callback)
                    _message_callback(shared_from_this(), &_in_buffer);
            }

            // 要么就是写入数据的时候出错关闭,要么就是没有待发送数据,直接关闭
            if (_out_buffer.ReadAbleSize() > 0)
            {
                if (_channel.WriteAble() == false)
                {
                    _channel.EnableWrite();
                }
            }

            if (_out_buffer.ReadAbleSize() == 0)
            {
                Release();
            }
        }

        // 启动非活跃连接超时的释放规则
        void EnableInactiveReleaseInLoop(int sec)
        {
            // 1.将判断标志 _enable_inactive_release 置为true
            _enable_inactive_release = true;
            // 2.如果当前定时器销毁任务已经存在,那就刷新延迟一下时间
            if (_loop->HasTimer(_conn_id))
            {
                return _loop->TimerRefresh(sec);
            }
            // 3.如果不存在定时销毁任务,则新增
            _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::Release, this));
        }

        void CancelInactiveReleaseInLoop()
        {
            _enable_inactive_release = false;
            if (_loop->HasTimer(_conn_id))
            {
                _loop->TimerCancel(_conn_id);
            }
        }

        void UpgrateInLoop(const Any &context,
                           const ConnectedCallback &conn,
                           const MessageCallback &msg,
                           const ClosedCallback &closed,
                           const AnyEventCallback &event)
        {
            _context = context;
            _connected_callback = conn;
            _message_callback = msg;
            _closed_callback = closed;
            _event_callback = event;
        }

    public:
        Connection(EventLoop *loop, const uint64_t &conn_id, int sockfd, const std::string &clientIp)
            : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false), _loop(loop),
              _statu(CONNECTING), _socket(sockfd), _channel(loop, _sockfd), _clientIp(clientIp)
        {
            _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
            _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
            _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
            _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
            _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        }

        ~Connection()
        {
            LOG_ERROR("~Connection: release connection: {}", (void *)this);
        }

        // 获取管理的文件描述符
        int Fd() { return _sockfd; }
        // 获取连接ID
        int Id() { return _conn_id; }
        // 是否处于CONNECTED状态
        bool Connected() { return _statu == CONNECTED; }
        // 设置上下文
        void SetContext(const Any &context) { _context = context; }
        // 获取上下文,返回的是指针
        Any *GetContext() { return &_context; }

        // 获取客户端IP
        std::string ClientIp() { return _clientIp; }

        void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
        void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
        void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
        void SetAnyEventedCallback(const AnyEventCallback &cb) { _event_callback = cb; }
        void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }

        // 连接建立就绪后,进行channel回调设置,启动读监控,调用_connected_callback
        void Established()
        {
            return _loop->RunInLoop(std::bind(&Connection::EstableishdInLoop, this));
        }

        // 发送数据,将数据放到发送缓冲区,启动写事件监控
        void Send(const char *data, size_t len)
        {
            // 外界传入的data,可能是个临时的空间,我们现在只是把发送操作压入了任务池
            // 有可能并没有被立即执行
            // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
            Buffer buffer;
            buffer.WriteAndPush(data, len);
            return _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, std::move(buffer)));
        }

        // 提供给组件使用者的关闭接口 --并不实际关闭,需要判断有没有数据待处理
        void Shutdown()
        {
            return _loop->RunInLoop(std::bind(&Connection::ShutDownInLoop, this));
        }

        void Release()
        {
            _loop->QueueInLoop(std::bind(&Connection::ReleaseInLoop, this));
        }

        // 启动非活跃销毁,并定义多长时间无通信就是非活跃,添加定时任务
        void EnableInactiveRelease(int sec)
        {
            return _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
        }

        // 取消非活跃销毁
        void CancleInactiveRelease()
        {
            return _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
        }

        // 切换协议--重置上下文以及阶段性处理函数
        void Update(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                    const ClosedCallback &closed, const AnyEventCallback &event)
        {
            _loop->AssertInLoop();
            _loop->RunInLoop(std::bind(&Connection::UpgrateInLoop, this, context, conn, msg, closed, event));
        }
    };
}